<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<script src="../../js/jquery.min.js"></script>
<body style="">

<canvas id="canvas" width="1920" height="883"></canvas>

<script>
    $(function() {

        //Indention is a bit f*d up

        //Set animation frame
        window.requestAnimationFrame = window.requestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || window.msRequestAnimationFrame;


        var canvas = $('#canvas')[0],
            ctx = canvas.getContext('2d'),
            canvasW = $(document).width(),
            canvasH = $(document).height();

        ctx.fillStyle = 'black';

        canvas.width = canvasW;
        canvas.height = canvasH;

        var mouse = {
            x: canvasW/2,
            y: canvasH/2,
            dx: 0,
            dy: 0
        };

        var emitter = {
            h: 50,
            x: canvasW/2-250,
            y: canvasH/2,
            vx: 5,
            vy: 5,
            v: 0.05,
            dx: 0,
            dy: 0
        };

        var stops = [50, 150, 160, 300, 500],
            stopIndex = 0,
            delay = 0,
            prog = 0;

        var circle = {
            radius: 125,
            angle: 0
        };

        var particles = new Array();

        var rate = 2,
            time = 0,
            frameIndex = rate;

        var simplex = new SimplexNoise(),
            simplexVal = 0,
            simplexStart = 20;

        //Start loop
        draw();

        //Draw
        function draw() {

            ctx.globalCompositeOperation = 'source-over';
            ctx.fillStyle = 'rgba(0,0,0,0.5)';
            ctx.fillRect(0, 0, canvasW, canvasH);
            ctx.globalCompositeOperation = 'lighter';

            //Draw loading
            ctx.fillStyle = '#000';
            ctx.fillRect(canvasW/2-250, emitter.y-emitter.h/2, 500, emitter.h);
            ctx.strokeStyle = 'rgba(0,255,0,0.5)';
            ctx.strokeRect(canvasW/2-250, emitter.y-emitter.h/2, 500, emitter.h);
            ctx.font = '20pt Arial';
            ctx.fillStyle = 'rgba(0,255,0,0.5)';
            ctx.fillText(Math.floor(prog/5)+'%', canvasW/2-20, canvasH/2+10);

            //Move emitter
            //console.log(stops[stopIndex]+' '+prog+' '+delay);
            if(stops[stopIndex] == prog) {
                stopIndex ++;
                delay = 50;
            } else {
                if(delay == 0 && prog < stops[stopIndex]) {
                    emitter.dx = -1;
                    emitter.x += 2;
                    prog += 2;
                } else {
                    emitter.dx = 0;
                    delay --;
                }
            }

            //Draw emitter
            ctx.fillStyle = '#0f0';
            ctx.fillRect(emitter.x, emitter.y-emitter.h/2, 1, emitter.h);

            //Draw particles
            var i = 0;
            for(i in particles) {
                var p = particles[i];

                //Check if die
                if(time > p.die) {
                    p.o -= 0.01;
                    if(p.o < 0) {
                        particles.splice(i, 1);
                    }
                }

                //Add v
                p.x += p.vx;
                p.y += p.vy;

                //Add source move
                p.x += p.sourcedx / 10;
                p.y += p.sourcedy / 10;

                //Simplex noise
                if(p.simplexIndex > simplexStart) {
                    p.simplexVal = simplex.noise3D(p.x/100, p.y/100, time/100);
                }

                p.simplexIndex ++;
                p.x += p.simplexVal;
                p.y += p.simplexVal;

                //If (almost) outside canvas
                if(p.x < 0+20 || p.x > canvasW-20) {
                    p.vx *= -1.015;
                }
                if(p.y < 0+20 || p.y > canvasH-20) {
                    p.vy *= -1.015;
                }

                ctx.beginPath();
                ctx.fillStyle = 'rgba(0, '+p.green+', 0, '+p.o+')';
                ctx.arc(p.x, p.y, p.r, 0, 2 * Math.PI, true);
                ctx.fill();
                ctx.save();
            }

            //if emitter is moving
            if(emitter.dx !== 0) {
                for(var i=0; i<rate; i++) {
                    //Create particle
                    var particle = {
                        x: emitter.x,
                        y: emitter.y+(Math.random()*emitter.h-emitter.h/2),
                        r: Math.random()+0.5,
                        vx: (Math.random()*-2),
                        vy: (Math.random()-0.5),
                        o: 1,
                        birth: time,
                        die: time+(Math.random()*50+50),//1+1),
                        sourcedx: emitter.dx,
                        sourcedy: emitter.dy,
                        red: Math.round(Math.random()*255),
                        green: Math.round(Math.random()*255),
                        blue: Math.round(Math.random()*255),
                        simplexVal: 0,
                        simplexIndex: 0
                    };

                    particles.push(particle);
                }
            }

            time++;
            window.requestAnimationFrame(draw);

        }

        $(window).mousemove(function(e) {
            mouse.dx = e.pageX - mouse.x;
            mouse.dy = e.pageY - mouse.y;

            mouse.x = e.pageX;
            mouse.y = e.pageY;
        });


    });


    /*
     * A fast javascript implementation of simplex noise by Jonas Wagner
     *
     * Based on a speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
     * Which is based on example code by Stefan Gustavson (stegu@itn.liu.se).
     * With Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
     * Better rank ordering method by Stefan Gustavson in 2012.
     *
     *
     * Copyright (C) 2012 Jonas Wagner
     *
     * Permission is hereby granted, free of charge, to any person obtaining
     * a copy of this software and associated documentation files (the
     * "Software"), to deal in the Software without restriction, including
     * without limitation the rights to use, copy, modify, merge, publish,
     * distribute, sublicense, and/or sell copies of the Software, and to
     * permit persons to whom the Software is furnished to do so, subject to
     * the following conditions:
     *
     * The above copyright notice and this permission notice shall be
     * included in all copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
     * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
     * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
     * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
     * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     *
     */
    (function () {

        var F2 = 0.5 * (Math.sqrt(3.0) - 1.0),
            G2 = (3.0 - Math.sqrt(3.0)) / 6.0,
            F3 = 1.0 / 3.0,
            G3 = 1.0 / 6.0,
            F4 = (Math.sqrt(5.0) - 1.0) / 4.0,
            G4 = (5.0 - Math.sqrt(5.0)) / 20.0;


        function SimplexNoise(random) {
            if (!random) random = Math.random;
            this.p = new Uint8Array(256);
            this.perm = new Uint8Array(512);
            this.permMod12 = new Uint8Array(512);
            for (var i = 0; i < 256; i++) {
                this.p[i] = random() * 256;
            }
            for (i = 0; i < 512; i++) {
                this.perm[i] = this.p[i & 255];
                this.permMod12[i] = this.perm[i] % 12;
            }

        }
        SimplexNoise.prototype = {
            grad3: new Float32Array([1, 1, 0,
                - 1, 1, 0,
                1, - 1, 0,

                - 1, - 1, 0,
                1, 0, 1,
                - 1, 0, 1,

                1, 0, - 1,
                - 1, 0, - 1,
                0, 1, 1,

                0, - 1, 1,
                0, 1, - 1,
                0, - 1, - 1]),
            grad4: new Float32Array([0, 1, 1, 1, 0, 1, 1, - 1, 0, 1, - 1, 1, 0, 1, - 1, - 1,
                0, - 1, 1, 1, 0, - 1, 1, - 1, 0, - 1, - 1, 1, 0, - 1, - 1, - 1,
                1, 0, 1, 1, 1, 0, 1, - 1, 1, 0, - 1, 1, 1, 0, - 1, - 1,
                - 1, 0, 1, 1, - 1, 0, 1, - 1, - 1, 0, - 1, 1, - 1, 0, - 1, - 1,
                1, 1, 0, 1, 1, 1, 0, - 1, 1, - 1, 0, 1, 1, - 1, 0, - 1,
                - 1, 1, 0, 1, - 1, 1, 0, - 1, - 1, - 1, 0, 1, - 1, - 1, 0, - 1,
                1, 1, 1, 0, 1, 1, - 1, 0, 1, - 1, 1, 0, 1, - 1, - 1, 0,
                - 1, 1, 1, 0, - 1, 1, - 1, 0, - 1, - 1, 1, 0, - 1, - 1, - 1, 0]),
            noise2D: function (xin, yin) {
                var permMod12 = this.permMod12,
                    perm = this.perm,
                    grad3 = this.grad3;
                var n0=0, n1=0, n2=0; // Noise contributions from the three corners
                // Skew the input space to determine which simplex cell we're in
                var s = (xin + yin) * F2; // Hairy factor for 2D
                var i = Math.floor(xin + s);
                var j = Math.floor(yin + s);
                var t = (i + j) * G2;
                var X0 = i - t; // Unskew the cell origin back to (x,y) space
                var Y0 = j - t;
                var x0 = xin - X0; // The x,y distances from the cell origin
                var y0 = yin - Y0;
                // For the 2D case, the simplex shape is an equilateral triangle.
                // Determine which simplex we are in.
                var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
                if (x0 > y0) {
                    i1 = 1;
                    j1 = 0;
                } // lower triangle, XY order: (0,0)->(1,0)->(1,1)
                else {
                    i1 = 0;
                    j1 = 1;
                } // upper triangle, YX order: (0,0)->(0,1)->(1,1)
                // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
                // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
                // c = (3-sqrt(3))/6
                var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
                var y1 = y0 - j1 + G2;
                var x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
                var y2 = y0 - 1.0 + 2.0 * G2;
                // Work out the hashed gradient indices of the three simplex corners
                var ii = i & 255;
                var jj = j & 255;
                // Calculate the contribution from the three corners
                var t0 = 0.5 - x0 * x0 - y0 * y0;
                if (t0 >= 0) {
                    var gi0 = permMod12[ii + perm[jj]] * 3;
                    t0 *= t0;
                    n0 = t0 * t0 * (grad3[gi0] * x0 + grad3[gi0 + 1] * y0); // (x,y) of grad3 used for 2D gradient
                }
                var t1 = 0.5 - x1 * x1 - y1 * y1;
                if (t1 >= 0) {
                    var gi1 = permMod12[ii + i1 + perm[jj + j1]] * 3;
                    t1 *= t1;
                    n1 = t1 * t1 * (grad3[gi1] * x1 + grad3[gi1 + 1] * y1);
                }
                var t2 = 0.5 - x2 * x2 - y2 * y2;
                if (t2 >= 0) {
                    var gi2 = permMod12[ii + 1 + perm[jj + 1]] * 3;
                    t2 *= t2;
                    n2 = t2 * t2 * (grad3[gi2] * x2 + grad3[gi2 + 1] * y2);
                }
                // Add contributions from each corner to get the final noise value.
                // The result is scaled to return values in the interval [-1,1].
                return 70.0 * (n0 + n1 + n2);
            },
            // 3D simplex noise
            noise3D: function (xin, yin, zin) {
                var permMod12 = this.permMod12,
                    perm = this.perm,
                    grad3 = this.grad3;
                var n0, n1, n2, n3; // Noise contributions from the four corners
                // Skew the input space to determine which simplex cell we're in
                var s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D
                var i = Math.floor(xin + s);
                var j = Math.floor(yin + s);
                var k = Math.floor(zin + s);
                var t = (i + j + k) * G3;
                var X0 = i - t; // Unskew the cell origin back to (x,y,z) space
                var Y0 = j - t;
                var Z0 = k - t;
                var x0 = xin - X0; // The x,y,z distances from the cell origin
                var y0 = yin - Y0;
                var z0 = zin - Z0;
                // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
                // Determine which simplex we are in.
                var i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
                var i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
                if (x0 >= y0) {
                    if (y0 >= z0) {
                        i1 = 1;
                        j1 = 0;
                        k1 = 0;
                        i2 = 1;
                        j2 = 1;
                        k2 = 0;
                    } // X Y Z order
                    else if (x0 >= z0) {
                        i1 = 1;
                        j1 = 0;
                        k1 = 0;
                        i2 = 1;
                        j2 = 0;
                        k2 = 1;
                    } // X Z Y order
                    else {
                        i1 = 0;
                        j1 = 0;
                        k1 = 1;
                        i2 = 1;
                        j2 = 0;
                        k2 = 1;
                    } // Z X Y order
                }
                else { // x0<y0
                    if (y0 < z0) {
                        i1 = 0;
                        j1 = 0;
                        k1 = 1;
                        i2 = 0;
                        j2 = 1;
                        k2 = 1;
                    } // Z Y X order
                    else if (x0 < z0) {
                        i1 = 0;
                        j1 = 1;
                        k1 = 0;
                        i2 = 0;
                        j2 = 1;
                        k2 = 1;
                    } // Y Z X order
                    else {
                        i1 = 0;
                        j1 = 1;
                        k1 = 0;
                        i2 = 1;
                        j2 = 1;
                        k2 = 0;
                    } // Y X Z order
                }
                // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
                // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
                // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
                // c = 1/6.
                var x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
                var y1 = y0 - j1 + G3;
                var z1 = z0 - k1 + G3;
                var x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
                var y2 = y0 - j2 + 2.0 * G3;
                var z2 = z0 - k2 + 2.0 * G3;
                var x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
                var y3 = y0 - 1.0 + 3.0 * G3;
                var z3 = z0 - 1.0 + 3.0 * G3;
                // Work out the hashed gradient indices of the four simplex corners
                var ii = i & 255;
                var jj = j & 255;
                var kk = k & 255;
                // Calculate the contribution from the four corners
                var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
                if (t0 < 0) n0 = 0.0;
                else {
                    var gi0 = permMod12[ii + perm[jj + perm[kk]]] * 3;
                    t0 *= t0;
                    n0 = t0 * t0 * (grad3[gi0] * x0 + grad3[gi0 + 1] * y0 + grad3[gi0 + 2] * z0);
                }
                var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
                if (t1 < 0) n1 = 0.0;
                else {
                    var gi1 = permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]] * 3;
                    t1 *= t1;
                    n1 = t1 * t1 * (grad3[gi1] * x1 + grad3[gi1 + 1] * y1 + grad3[gi1 + 2] * z1);
                }
                var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
                if (t2 < 0) n2 = 0.0;
                else {
                    var gi2 = permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]] * 3;
                    t2 *= t2;
                    n2 = t2 * t2 * (grad3[gi2] * x2 + grad3[gi2 + 1] * y2 + grad3[gi2 + 2] * z2);
                }
                var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
                if (t3 < 0) n3 = 0.0;
                else {
                    var gi3 = permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]] * 3;
                    t3 *= t3;
                    n3 = t3 * t3 * (grad3[gi3] * x3 + grad3[gi3 + 1] * y3 + grad3[gi3 + 2] * z3);
                }
                // Add contributions from each corner to get the final noise value.
                // The result is scaled to stay just inside [-1,1]
                return 32.0 * (n0 + n1 + n2 + n3);
            },
            // 4D simplex noise, better simplex rank ordering method 2012-03-09
            noise4D: function (x, y, z, w) {
                var permMod12 = this.permMod12,
                    perm = this.perm,
                    grad4 = this.grad4;

                var n0, n1, n2, n3, n4; // Noise contributions from the five corners
                // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
                var s = (x + y + z + w) * F4; // Factor for 4D skewing
                var i = Math.floor(x + s);
                var j = Math.floor(y + s);
                var k = Math.floor(z + s);
                var l = Math.floor(w + s);
                var t = (i + j + k + l) * G4; // Factor for 4D unskewing
                var X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
                var Y0 = j - t;
                var Z0 = k - t;
                var W0 = l - t;
                var x0 = x - X0; // The x,y,z,w distances from the cell origin
                var y0 = y - Y0;
                var z0 = z - Z0;
                var w0 = w - W0;
                // For the 4D case, the simplex is a 4D shape I won't even try to describe.
                // To find out which of the 24 possible simplices we're in, we need to
                // determine the magnitude ordering of x0, y0, z0 and w0.
                // Six pair-wise comparisons are performed between each possible pair
                // of the four coordinates, and the results are used to rank the numbers.
                var rankx = 0;
                var ranky = 0;
                var rankz = 0;
                var rankw = 0;
                if (x0 > y0) rankx++;
                else ranky++;
                if (x0 > z0) rankx++;
                else rankz++;
                if (x0 > w0) rankx++;
                else rankw++;
                if (y0 > z0) ranky++;
                else rankz++;
                if (y0 > w0) ranky++;
                else rankw++;
                if (z0 > w0) rankz++;
                else rankw++;
                var i1, j1, k1, l1; // The integer offsets for the second simplex corner
                var i2, j2, k2, l2; // The integer offsets for the third simplex corner
                var i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
                // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
                // Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
                // impossible. Only the 24 indices which have non-zero entries make any sense.
                // We use a thresholding to set the coordinates in turn from the largest magnitude.
                // Rank 3 denotes the largest coordinate.
                i1 = rankx >= 3 ? 1 : 0;
                j1 = ranky >= 3 ? 1 : 0;
                k1 = rankz >= 3 ? 1 : 0;
                l1 = rankw >= 3 ? 1 : 0;
                // Rank 2 denotes the second largest coordinate.
                i2 = rankx >= 2 ? 1 : 0;
                j2 = ranky >= 2 ? 1 : 0;
                k2 = rankz >= 2 ? 1 : 0;
                l2 = rankw >= 2 ? 1 : 0;
                // Rank 1 denotes the second smallest coordinate.
                i3 = rankx >= 1 ? 1 : 0;
                j3 = ranky >= 1 ? 1 : 0;
                k3 = rankz >= 1 ? 1 : 0;
                l3 = rankw >= 1 ? 1 : 0;
                // The fifth corner has all coordinate offsets = 1, so no need to compute that.
                var x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
                var y1 = y0 - j1 + G4;
                var z1 = z0 - k1 + G4;
                var w1 = w0 - l1 + G4;
                var x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
                var y2 = y0 - j2 + 2.0 * G4;
                var z2 = z0 - k2 + 2.0 * G4;
                var w2 = w0 - l2 + 2.0 * G4;
                var x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
                var y3 = y0 - j3 + 3.0 * G4;
                var z3 = z0 - k3 + 3.0 * G4;
                var w3 = w0 - l3 + 3.0 * G4;
                var x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
                var y4 = y0 - 1.0 + 4.0 * G4;
                var z4 = z0 - 1.0 + 4.0 * G4;
                var w4 = w0 - 1.0 + 4.0 * G4;
                // Work out the hashed gradient indices of the five simplex corners
                var ii = i & 255;
                var jj = j & 255;
                var kk = k & 255;
                var ll = l & 255;
                // Calculate the contribution from the five corners
                var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
                if (t0 < 0) n0 = 0.0;
                else {
                    var gi0 = (perm[ii + perm[jj + perm[kk + perm[ll]]]] % 32) * 4;
                    t0 *= t0;
                    n0 = t0 * t0 * (grad4[gi0] * x0 + grad4[gi0 + 1] * y0 + grad4[gi0 + 2] * z0 + grad4[gi0 + 3] * w0);
                }
                var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
                if (t1 < 0) n1 = 0.0;
                else {
                    var gi1 = (perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] % 32) * 4;
                    t1 *= t1;
                    n1 = t1 * t1 * (grad4[gi1] * x1 + grad4[gi1 + 1] * y1 + grad4[gi1 + 2] * z1 + grad4[gi1 + 3] * w1);
                }
                var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
                if (t2 < 0) n2 = 0.0;
                else {
                    var gi2 = (perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] % 32) * 4;
                    t2 *= t2;
                    n2 = t2 * t2 * (grad4[gi2] * x2 + grad4[gi2 + 1] * y2 + grad4[gi2 + 2] * z2 + grad4[gi2 + 3] * w2);
                }
                var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
                if (t3 < 0) n3 = 0.0;
                else {
                    var gi3 = (perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] % 32) * 4;
                    t3 *= t3;
                    n3 = t3 * t3 * (grad4[gi3] * x3 + grad4[gi3 + 1] * y3 + grad4[gi3 + 2] * z3 + grad4[gi3 + 3] * w3);
                }
                var t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
                if (t4 < 0) n4 = 0.0;
                else {
                    var gi4 = (perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32) * 4;
                    t4 *= t4;
                    n4 = t4 * t4 * (grad4[gi4] * x4 + grad4[gi4 + 1] * y4 + grad4[gi4 + 2] * z4 + grad4[gi4 + 3] * w4);
                }
                // Sum up and scale the result to cover the range [-1,1]
                return 27.0 * (n0 + n1 + n2 + n3 + n4);
            }


        };

// amd
        if (typeof define !== 'undefined' && define.amd) define(function(){return SimplexNoise;});
//common js
        if (typeof exports !== 'undefined') exports.SimplexNoise = SimplexNoise;
// browser
        else if (typeof navigator !== 'undefined') this.SimplexNoise = SimplexNoise;
// nodejs
        if (typeof module !== 'undefined') {
            module.exports = SimplexNoise;
        }

    })();
</script>

</body>
</html>